﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using Microsoft.Win32;
using System.Security.AccessControl;
using System.Security.Cryptography;
using System.Runtime.InteropServices;
using System.Drawing;

namespace Check_List
{
	public static class csUtil
	{

	#region Nome de arquivo
		public enum enuParteNomeArquivo
		{
			CaminhoCompleto,
			Pasta,
			Nome,
			Extencao,
			NomeExtencao
		}

		public static string ParteNomeArquivo(string CaminhoCompleto, enuParteNomeArquivo QualParte)
		{
			string Retorno = "";
			string[] vetSplit;
			if (CaminhoCompleto.Trim().Length > 0)
			{
				switch (QualParte)
				{
					case enuParteNomeArquivo.CaminhoCompleto:
						Retorno = CaminhoCompleto;
						break;
					case enuParteNomeArquivo.Pasta:
						vetSplit = CaminhoCompleto.Split(new Char[] { '\\' });
						for (int i = 0; i <= vetSplit.Length - 2; i++)
						{
							Retorno = Retorno + vetSplit[i] + "\\";
						}
						break;
					case enuParteNomeArquivo.Nome:
						vetSplit = CaminhoCompleto.Split(new Char[] { '\\' });
						vetSplit = vetSplit[vetSplit.Length - 1].Split(new Char[] { '.' });
                        if (vetSplit.Length == 1)
                        {
                            Retorno = vetSplit[0];
                        }
                        else
                        {
                            for (int i = 0; i <= vetSplit.Length - 2; i++)
                            {
                                Retorno = Retorno + vetSplit[i];
                                if (i < vetSplit.Length - 2)
                                {
                                    Retorno = Retorno + ".";
                                }
                            }
                        }
						break;
					case enuParteNomeArquivo.Extencao:
						vetSplit = CaminhoCompleto.Split(new Char[] { '\\' });
						vetSplit = vetSplit[vetSplit.Length - 1].Split(new Char[] { '.' });
                        if (vetSplit.Length == 1)
                        {
                            Retorno = "";
                        }
                        else
                        {
                            Retorno = vetSplit[vetSplit.Length - 1];
                        }
						break;
					case enuParteNomeArquivo.NomeExtencao:
						vetSplit = CaminhoCompleto.Split(new Char[] { '\\' });
						Retorno = vetSplit[vetSplit.Length - 1];
						break;
				}
			}

			return Retorno;
		}
	#endregion

	#region Registro do windows
		public enum enuChaveRegistro
		{
			ClassesRoot,
			CurrentUser,
			LocalMachine,
			Users,
			CurrentConfig
		}

		public static void RegSalva(enuChaveRegistro Chave, string SubChave, Hashtable Valores)
		{
			RegistryKey RegChave = AbreSubChave(Chave, SubChave);
			if (RegChave == null)
			{
				RegChave = CriaSubChave(Chave, SubChave);
			}

			foreach (string HashKey in Valores.Keys)
			{
				RegChave.SetValue(HashKey, Valores[HashKey]);
			}

		}

		public static Hashtable RegBusca(enuChaveRegistro Chave, string SubChave)
		{
			RegistryKey RegChave = AbreSubChave(Chave, SubChave);

			Hashtable Retorno = new Hashtable();
			if (RegChave != null)
			{
				string[] NomeCampos = RegChave.GetValueNames();
				foreach (string Nome in NomeCampos)
				{
					Retorno.Add(Nome, RegChave.GetValue(Nome));
				}
				RegChave.Close();
			}
			return Retorno;
		}

		public static Hashtable RegBusca(enuChaveRegistro Chave, string SubChave, string NomeCampo)
		{
			RegistryKey RegChave = AbreSubChave(Chave, SubChave);

			Hashtable Retorno = new Hashtable();
			Retorno.Add(NomeCampo, RegChave.GetValue(NomeCampo));
			return Retorno;
		}

		private static RegistryKey CriaSubChave(enuChaveRegistro Chave, string SubChave)
		{
			RegistryKey RegChave = null;

			string UsuarioLogado = Environment.UserDomainName + "\\" + Environment.UserName;
			RegistrySecurity SegurancaUsuario = new RegistrySecurity();
			RegistryAccessRule RegraUsuario = new RegistryAccessRule(UsuarioLogado, RegistryRights.FullControl, AccessControlType.Allow);
			SegurancaUsuario.AddAccessRule(RegraUsuario);

			string[] Chaves = SubChave.Split(new Char[] { '\\' });
			string SubChaveConcat = "";

			foreach (string SubChaveItem in Chaves)
			{
				if (SubChaveConcat.Length == 0)
					SubChaveConcat = SubChaveConcat + SubChaveItem;
				else
					SubChaveConcat = SubChaveConcat + "\\" + SubChaveItem;
				RegChave = AbreSubChave(Chave, SubChaveConcat);
				if (RegChave == null)
				{
					switch (Chave)
					{
						case enuChaveRegistro.ClassesRoot:
							RegChave = Registry.ClassesRoot.CreateSubKey(SubChaveConcat, RegistryKeyPermissionCheck.ReadWriteSubTree, SegurancaUsuario);
							break;
						case enuChaveRegistro.CurrentUser:
							RegChave = Registry.CurrentUser.CreateSubKey(SubChaveConcat, RegistryKeyPermissionCheck.ReadWriteSubTree, SegurancaUsuario);
							break;
						case enuChaveRegistro.LocalMachine:
							RegChave = Registry.LocalMachine.CreateSubKey(SubChaveConcat, RegistryKeyPermissionCheck.ReadWriteSubTree, SegurancaUsuario);
							break;
						case enuChaveRegistro.Users:
							RegChave = Registry.Users.CreateSubKey(SubChaveConcat, RegistryKeyPermissionCheck.ReadWriteSubTree, SegurancaUsuario);
							break;
						case enuChaveRegistro.CurrentConfig:
							RegChave = Registry.CurrentConfig.CreateSubKey(SubChaveConcat, RegistryKeyPermissionCheck.ReadWriteSubTree, SegurancaUsuario);
							break;
					}
				}
				RegChave.SetAccessControl(SegurancaUsuario);
			}
			return RegChave;
		}

		private static RegistryKey AbreSubChave(enuChaveRegistro Chave, string SubChave)
		{
			RegistryKey RegChave = null;
			switch (Chave)
			{
				case enuChaveRegistro.ClassesRoot:
					RegChave = Registry.ClassesRoot.OpenSubKey(SubChave, true);
					break;
				case enuChaveRegistro.CurrentUser:
					RegChave = Registry.CurrentUser.OpenSubKey(SubChave, true);
					break;
				case enuChaveRegistro.LocalMachine:
					RegChave = Registry.LocalMachine.OpenSubKey(SubChave, true);
					break;
				case enuChaveRegistro.Users:
					RegChave = Registry.Users.OpenSubKey(SubChave, true);
					break;
				case enuChaveRegistro.CurrentConfig:
					RegChave = Registry.CurrentConfig.OpenSubKey(SubChave, true);
					break;
			}
			return RegChave;
		}

	#endregion

    #region Preferencias de usuário

        /// <summary>
        /// Carrega o valor salvo no registro em SOFTWARE\CheckListWizard\Preferencias.
        /// </summary>
        public static object CarregarPreferencia(string p_Campo)
        {
            object Retorno = null;
            try
            {
                RegistryKey PreferenciasUsuario = Registry.CurrentUser.OpenSubKey("SOFTWARE\\CheckListWizard\\Preferencias", true);

                if (PreferenciasUsuario != null)
                {
                    Retorno = PreferenciasUsuario.GetValue(p_Campo);
                    return Retorno;
                }
                else
                {
                    
                    return null;
                }
            }
            catch (Exception _Exception)
            {
                MessageBox.Show("Problemas para ler o registro do windows\n" + _Exception.ToString(), "Carrega Ultimo Valor", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return null;
            }
        }

        /// <summary>
        /// Salva o valor no registro em SOFTWARE\CheckListWizard\Preferencias.
        /// </summary>
        public static void SalvarPreferencia(string p_NomeCampo, object p_ValorCampo)
        {
            
            try
            {
                RegistryKey PreferenciasUsuario = Registry.CurrentUser.OpenSubKey("SOFTWARE\\CheckListWizard\\Preferencias", true);

                if (PreferenciasUsuario == null)
                {
                    PreferenciasUsuario = Registry.CurrentUser.OpenSubKey("SOFTWARE\\CheckListWizard", true);
                    if (PreferenciasUsuario == null)
                    {
                        PreferenciasUsuario = Registry.CurrentUser.OpenSubKey("SOFTWARE", true);
                        PreferenciasUsuario.CreateSubKey("CheckListWizard");
                    }
                    PreferenciasUsuario = Registry.CurrentUser.OpenSubKey("SOFTWARE\\CheckListWizard\\Preferencias", true);
                    if (PreferenciasUsuario == null)
                    {
                        PreferenciasUsuario = Registry.CurrentUser.OpenSubKey("SOFTWARE\\CheckListWizard", true);
                        PreferenciasUsuario.CreateSubKey("Preferencias");
                    }
                    PreferenciasUsuario = Registry.CurrentUser.OpenSubKey("SOFTWARE\\CheckListWizard\\Preferencias", true);
                }
                PreferenciasUsuario.SetValue(p_NomeCampo, p_ValorCampo);
                //
            }
            catch (Exception _Exception)
            {
                MessageBox.Show("Problemas para escrever no registro do windows\n" + _Exception.ToString(), "Salvar valor padrão", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            
        }
    #endregion

    #region Formularios
        public static void CentralizaForm(Form Formulario)
		{
			if (Formulario.Width < Screen.PrimaryScreen.WorkingArea.Width)
			{
				Formulario.Left = (Screen.PrimaryScreen.WorkingArea.Width / 2) - (Formulario.Width / 2);
			}
			else
			{
				Formulario.Left = 0;
			}

			if (Formulario.Height < Screen.PrimaryScreen.WorkingArea.Height)
			{
				Formulario.Top = (Screen.PrimaryScreen.WorkingArea.Height / 2) - (Formulario.Height / 2);
			}
			else
			{
				Formulario.Top = 0;
			}
		}
    #endregion

    #region Dialogs
        public static DialogResult InputBox(string p_Titulo, string p_Descricao, ref string p_Texto)
        {
            Form form = new Form();
            Label label = new Label();
            TextBox textBox = new TextBox();
            Button buttonOk = new Button();
            Button buttonCancel = new Button();

            form.Text = p_Titulo;
            label.Text = p_Descricao;
            textBox.Text = p_Texto;

            buttonOk.Text = "OK";
            buttonCancel.Text = "Cancelar";
            buttonOk.DialogResult = DialogResult.OK;
            buttonCancel.DialogResult = DialogResult.Cancel;

            label.SetBounds(9, 20, 372, 13);
            textBox.SetBounds(12, 36, 372, 20);
            buttonOk.SetBounds(228, 72, 75, 23);
            buttonCancel.SetBounds(309, 72, 75, 23);

            label.AutoSize = true;
            textBox.Anchor = textBox.Anchor | AnchorStyles.Right;
            buttonOk.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
            buttonCancel.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;

            form.ClientSize = new Size(396, 107);
            form.Controls.AddRange(new Control[] { label, textBox, buttonOk, buttonCancel });
            form.ClientSize = new Size(Math.Max(300, label.Right + 10), form.ClientSize.Height);
            form.FormBorderStyle = FormBorderStyle.FixedDialog;
            form.StartPosition = FormStartPosition.CenterScreen;
            form.MinimizeBox = false;
            form.MaximizeBox = false;
            form.AcceptButton = buttonOk;
            form.CancelButton = buttonCancel;

            DialogResult dialogResult = form.ShowDialog();
            p_Texto = textBox.Text;
            return dialogResult;
        }
    #endregion

    #region Uso do programador
        // Serve para gerar o código com a largura inicial de uma DataGridView.
        // Monte a DataGridView, preencha com os dados, ajuste a largura das colunas na tela em execução e chame esta
        // rotina que ela monta o código com a largura ajustada em tela e joga na área de trasferência, depois é
        // só colar o código na inicialização do formulario
		public static void LarguraColunasDataGridView(DataGridView Grid)
		{
			string Ret = "";

			foreach (DataGridViewColumn item in Grid.Columns)
			{
				Ret = Ret + Grid.Name + ".Columns[" + item.Index.ToString() + "].Width = " + item.Width.ToString() + ";\r\n";
			}
			Clipboard.Clear();
			if (Ret.Length > 0)
				Clipboard.SetText(Ret);
		}
	#endregion

	#region Encriptação
		public static string EncriptarMD5(string Texto)
		{
			MD5CryptoServiceProvider Encriptador = new MD5CryptoServiceProvider();
			byte[] ascBytes = Encoding.ASCII.GetBytes(Texto);
			byte[] hashBytes = Encriptador.ComputeHash(ascBytes);

			StringBuilder sb = new StringBuilder();
			for (int c = 0; c < hashBytes.Length; c++)
				sb.AppendFormat("{0:x2}", hashBytes[c]);

			return sb.ToString();
		}
	#endregion

    #region Associação de tipo de arquivo
        public static void Associar(string p_Extencao,
               string p_NomePrograma, string p_Descricao, string p_CaminhoIcone, string p_CaminhoEXE)
        {
            Registry.ClassesRoot.CreateSubKey(p_Extencao).SetValue("", p_NomePrograma);
            if (p_NomePrograma != null && p_NomePrograma.Length > 0)
                using (RegistryKey key = Registry.ClassesRoot.CreateSubKey(p_NomePrograma))
                {
                    if (p_Descricao != null)
                        key.SetValue("", p_Descricao);
                    if (p_CaminhoIcone != null)
                        key.CreateSubKey("DefaultIcon").SetValue("", ToShortPathName(p_CaminhoIcone));
                    if (p_CaminhoEXE != null)
                        key.CreateSubKey(@"Shell\Open\Command").SetValue("",
                                    ToShortPathName(p_CaminhoEXE) + " \"%1\"");
                }
        }

        public static bool EstaAssociada(string p_Extencao)
        {
            return (Registry.ClassesRoot.OpenSubKey(p_Extencao, false) != null);
        }

        [DllImport("Kernel32.dll")]
        private static extern uint GetShortPathName(string lpszLongPath,
            [Out] StringBuilder lpszShortPath, uint cchBuffer);

        private static string ToShortPathName(string longName)
        {
            StringBuilder s = new StringBuilder(1000);
            uint iSize = (uint)s.Capacity;
            uint iRet = GetShortPathName(longName, s, iSize);
            return s.ToString();
        }
    #endregion
    }
}
